new Vue({
    el: '#app',
    data: {
        searchText: '',
        isSearchActive: false,
        isSearching: false,
        isLoading: false,
        currentLoadingText: '正在初始化...', // 新增：当前加载提示文本
        loadingTexts: [ // 新增：加载提示文本数组
            '正在分析您的搜索习惯...',
            '连接智能美食数据库...',
            '检测附近匹配的餐厅...',
            '加载个性化推荐算法...',
            '扫描用户历史偏好...',
            '匹配口味相似度...',
            '查询实时菜单信息...',
            '优化地理位置搜索...',
            '寻找隐藏的美食宝藏...',
            '分析热门菜品趋势...',
            '加载用户评价数据...',
            '构建美食知识图谱...',
            '筛选符合条件的食谱...',
            '检查餐厅营业状态...',
            '计算最佳路线...',
            '同步好友推荐...',
            '加载高清美食图片...',
            '准备智能推荐列表...',
            '生成搜索结果摘要...',
            '马上就好，请稍候...',
            '正在为您精心挑选...',
            'AI正在努力思考中...'
        ],
        loadingInterval: null, // 新增：用于存储定时器
        showContent: false,
        showHotPot: false,
        description: '',
        isThinking: false, // 新增：标识AI是否正在思考
        thinkingStage: '', // 新增：当前思考阶段 ('analyzing' | 'recommending' | 'completed')
        currentTip: '你可以问我关于美食的任何问题，例如"推荐北京的特色小吃"或"最适合夏天吃的菜"',
        aiTips: [
            '你可以问我关于美食的任何问题，例如"推荐北京的特色小吃"或"最适合夏天吃的菜"',
            '想了解某道菜的做法？直接搜索菜名+"做法"即可',
            '搜索"附近的餐厅"可以获取周边美食推荐',
            '输入食材名称，我可以推荐相关的美食做法',
            '对某种口味感兴趣？搜索"麻辣"、"酸甜"等关键词试试',
            '想找适合聚会的美食？搜索"聚餐"或"多人"',
            '寻找健康饮食建议？搜索"低脂"、"低糖"或"健康食谱"'
        ],
        hotKeywords: ['烤鸭', '火锅', '小龙虾', '烧烤', '川菜', '粤菜', '北京烤鸭', '麻辣香锅'],
        recommendations: [],
        userInfo: null, // 新增：存储用户信息
        searchResults: [],
        visibleRecommendations: [],
        visibleSearchResults: []
    },
    mounted() {
        // 创建背景动画
        //this.createBackgroundAnimation();
        // 加载数据
        this.loadData();
        // 定时切换AI提示
        this.startTipRotation();
    },
    methods: {
        // 加载数据
        loadData() {
            let data = null; // 初始化为 null
            try {
                // 尝试从 Android 获取 JSON 字符串
                const userInfoString = Android.ObtainUserInfo();
                //console.warn(userInfoString);
                console.log('Android.ObtainUserInfo() raw:', userInfoString);
                if (userInfoString) {
                            const parsedData = JSON.parse(userInfoString); // 解析 JSON 字符串
                            // 从 nameValuePairs 中提取数据
                            data = parsedData.nameValuePairs || {
                                latitude: parsedData.latitude || "39.9042",
                                longitude: parsedData.longitude || "116.4074",
                                userId: parsedData.userId || "1"
                            };
                    console.warn('Parsed UserInfo:', data);
                } else {
                     console.warn("Android.ObtainUserInfo() 返回空或无效数据");
                     // 如果 Android 返回空，使用模拟数据
                     data = { "latitude": "39.9042", "longitude": "116.4074", "userId": "testUser001"}; // 北京坐标示例
                     console.warn('使用模拟用户信息:', data);
                }
            } catch (e) {
                console.error("处理 Android.ObtainUserInfo() 出错:", e);
                // 获取失败或解析失败时使用模拟数据
                data = { "latitude": "39.9042", "longitude": "116.4074", "userId": "7"}; // 北京坐标示例
                console.log('获取用户信息失败，使用模拟用户信息:', data);
            }
            this.userInfo = data; // 存储用户信息
        },
        // 创建背景动画
        createBackgroundAnimation() {
            const container = document.querySelector('.background-animation');
            const ballCount = 4;
            
            for (let i = 0; i < ballCount; i++) {
                const ball = document.createElement('div');
                ball.classList.add('floating-ball');
                
                // 随机大小
                const size = Math.random() * 100 + 550;
                ball.style.width = `${size}px`;
                ball.style.height = `${size}px`;
                
                // 随机位置
                const posX = Math.random() * 100;
                const posY = Math.random() * 100;
                ball.style.left = `${posX}%`;
                ball.style.top = `${posY}%`;
                
                // 随机颜色
                const hue = Math.random() * 360;
                ball.style.background = `hsla(${hue}, 40%, 20%, 0.2)`;
                
                // 随机动画
                const duration = Math.random() * 20 + 15; // 增加基础时长，减慢速度
                const delay = Math.random() * 10; // 增加延迟随机性
                
                // 应用预定义的 'float' 动画，使用 'infinite' 代替 'infinite alternate' 实现循环
                ball.style.animation = `float ${duration}s ease-in-out ${delay}s infinite`; 
                
                // 可选：添加微小的初始随机偏移，避免起始过于一致
                // ball.style.transform = `translate(${Math.random() * 10 - 5}px, ${Math.random() * 10 - 5}px)`; 

                container.appendChild(ball);
            }
            
            // 移除动态添加 @keyframes 的代码
            // const style = document.createElement('style');
            // style.textContent = `...`;
            // document.head.appendChild(style);
        },
        



    // 文本截断函数，限制文本长度
    truncateText(text, maxLength = 20) {
        if (!text) return '';
        if (text.length <= maxLength) {
            return text;
        }
        return text.substring(0, maxLength) + '...';
    },
    
   // 图片加载错误处理
   imageError(event) {
    // 防止无限循环：检查当前src是否已经是默认图片
    if (event.target.src.indexOf('imgdef.webp') !== -1) {
        // 已经是默认图片了，不再替换
        console.warn('默认图片也加载失败:', event.target.src);
        // 移除error事件监听，防止再次触发
        event.target.removeEventListener('error', this.imageError);
        return;
    }
    
    // 处理图片加载失败，替换为默认图片
    event.target.src = 'file:///android_asset/img/imgdef.webp';
},


        // 开始AI提示轮换
        startTipRotation() {
            setInterval(() => {
                const randomIndex = Math.floor(Math.random() * this.aiTips.length);
                this.currentTip = this.aiTips[randomIndex];
            }, 5000); // 每5秒切换一次提示
        },
        
        // 使用热搜词
        useKeyword(keyword) {
            this.searchText = keyword;
            this.activateSearch();
            this.search();
        },
        
        // 激活搜索
        activateSearch() {
            this.isSearchActive = true;
            this.isSearching = true;
        },
        
// 新增：用于调用后端 API 的辅助函数
async fetchBackendData(endpoint, body) {
    try {
        // 注意：你需要根据实际情况确定后端的 URL
        // 例如：const backendBaseUrl = 'http://localhost:8000';
        const backendBaseUrl = 'http://visionsic.com:1120'; // 请替换为你的后端服务地址
        const response = await fetch(`${backendBaseUrl}${endpoint}`, {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                'Accept': 'application/json',
            },
            body: JSON.stringify(body)
        });
        if (!response.ok) {
            console.error(`Backend API error! Endpoint: ${endpoint}, Status: ${response.status}`);
            // 尝试读取错误信息
            let errorData;
            try {
                errorData = await response.json();
            } catch (e) {
                errorData = { message: await response.text() };
            }
            throw new Error(`Backend API request failed for ${endpoint}: ${errorData.message || response.statusText}`);
        }
        const data = await response.json();
        if (data.status !== 'success') {
             console.error(`Backend API returned error for ${endpoint}:`, data.message);
             throw new Error(`Backend API error for ${endpoint}: ${data.message}`);
        }
        return data.data || data; // 返回 data 字段或整个响应（根据你的 API 设计）
    } catch (error) {
        console.error(`Failed to fetch backend data from ${endpoint}:`, error);
        return null; // 返回 null 表示失败
    }
},



        // 新增：解析 AI 返回的 JSON 响应
        parseAIJsonResponse(aiContent) {
            if (!aiContent) {
                console.error('AI 响应内容为空');
                return null;
            }
            console.log('原始 AI 响应内容:', aiContent);
            let jsonString = aiContent.trim();

            // 尝试去除常见的 markdown 代码块标记
            if (jsonString.startsWith('```json')) {
                jsonString = jsonString.substring(7); // 去除 ```json
            } else if (jsonString.startsWith('```')) {
                 jsonString = jsonString.substring(3); // 去除 ```
            }
            if (jsonString.endsWith('```')) {
                jsonString = jsonString.substring(0, jsonString.length - 3); // 去除末尾的 ```
            }
            jsonString = jsonString.trim(); // 再次 trim

            // 如果去除标记后不是以 { 开头，尝试查找第一个 { 和最后一个 }
            if (!jsonString.startsWith('{') || !jsonString.endsWith('}')) {
                const startIndex = jsonString.indexOf('{');
                const endIndex = jsonString.lastIndexOf('}');
                if (startIndex !== -1 && endIndex !== -1 && endIndex > startIndex) {
                    jsonString = jsonString.substring(startIndex, endIndex + 1);
                    console.log('提取 {} 之间的内容:', jsonString);
                } else {
                    console.warn('在 AI 响应中未能找到有效的 JSON 对象结构。');
                    // 即使找不到，也尝试解析，让 JSON.parse 报错以便调试
                }
            }

            try {
                const result = JSON.parse(jsonString);
                console.log('成功解析 AI JSON:', result);
                return result;
            } catch (parseError) {
                console.error('解析 AI 返回的 JSON 失败:', parseError);
                console.error('尝试解析的无效 JSON 字符串:', jsonString);
                console.error('原始 AI 响应:', aiContent); // 打印原始响应帮助调试
                return null; // 返回 null 表示解析失败
            }
        },





// 修改后的 callAI 函数
async callAI(prompt) {
    // 确保思考状态正确设置
    this.isThinking = false; // 第一次不显示思考状态
    this.thinkingStage = 'analyzing';
    this.description = '正在分析您的搜索意图...'; // 显示分析提示
    
    // --- 第一次 AI 调用：分析用户意图 ---
    const firstSystemPrompt = `
    你是一个全能个人助理，你可以分析用户提出的问题，返回json格式数据，你需要返回的内容如下。

    - Category：类别（吃，喝，玩，乐，购）中选择。例如["吃", "喝"]
    - Type: 类型（活动，评论，好友）如果要查找好友则可以输出["好友"]，如果想要加入活动可以输出["活动"]。例如["评论", "活动"], 如果想要查询更多则可以输出["评论"]。评论中什么都能找到。
    - Target： 查询目标（自己/全局）如果用户要查询自己的历史记录则可输出["自己"]。例如["自己"]

    **重要：确保返回的 JSON 格式严格有效，可以直接被 JavaScript 的 JSON.parse() 解析。不要在 JSON 之外添加任何其他文本或解释。**
    问题示例1：我好饿啊，天气又好热不想出门。
    示例输出格式：
    {
      "Category": ["吃", "喝"],
      "Type": ["评论", "活动"],
      "Target": ["全局"]
    }
    问题示例2：你还记不记得，我之前吃过一个火锅特别好吃，貌似是在一家叫"超级啥啥"的店。
    示例输出格式：
    {
      "Category": ["吃", "喝"],
      "Type": ["评论", "活动"],
      "Target": ["自己"]
    }
    问题示例3：最近很无聊，想找几个朋友嗨皮。你帮我想想办法呗。
    示例输出格式：
    {
      "Category": ["玩", "乐"],
      "Type": ["活动", "好友", "评论"],
      "Target": ["全局"]
    }
    `;

    let firstUserPrompt = `搜索词: ${prompt}`;
    if (this.userInfo) {
        firstUserPrompt += `\n用户信息: ${JSON.stringify(this.userInfo)}`;
    }

    const firstRequestBody = {
        model: "wzd",
        temperature: 0.1,
        top_p: 0.1,
        messages: [
            { role: "system", content: firstSystemPrompt },
            { role: "user", content: firstUserPrompt }
        ],
        stream: true
    };

    let analysisResult;
    try {
        console.log('First AI Call Request:', JSON.stringify(firstRequestBody, null, 2));
        
        // 流式处理第一次AI调用
        const firstResponse = await fetch("https://api.leftnorth.com/v1/chat/completions", {
            method: 'POST',
            headers: {
                'Accept': 'text/event-stream',
                'Content-Type': 'application/json',
                'Authorization': `Bearer sk-dff7bc8e-084d-45a9-a837-c634e64ca71b`,
            },
            body: JSON.stringify(firstRequestBody)
        });

        if (!firstResponse.ok) {
            throw new Error(`First AI call HTTP error! status: ${firstResponse.status}`);
        }

        // 处理流式响应 - 第一次不显示思考内容
        const reader = firstResponse.body.getReader();
        const decoder = new TextDecoder();
        let buffer = '';
        let firstAllContent = '';
        let firstThinkingContent = '';
        let firstJsonContent = '';
        let isInThinking = false;
        let hasFoundJson = false;

        while (true) {
            const { done, value } = await reader.read();
            if (done) break;

            buffer += decoder.decode(value, { stream: true });
            const lines = buffer.split('\n');
            buffer = lines.pop() || '';

            for (const line of lines) {
                if (line.startsWith('data: ')) {
                    const data = line.slice(6).trim();
                    if (data === '[DONE]') continue;
                    if (data === '') continue;
                    
                    try {
                        const parsed = JSON.parse(data);
                        if (parsed.choices && parsed.choices[0] && parsed.choices[0].delta && parsed.choices[0].delta.content) {
                            const content = parsed.choices[0].delta.content;
                            firstAllContent += content;
                            
                            // 第一次AI调用时不显示思考内容，只收集数据
                            if (content.includes('<think>')) {
                                isInThinking = true;
                                const thinkStart = content.indexOf('<think>') + 7;
                                const beforeThink = content.substring(0, content.indexOf('<think>'));
                                const afterThink = content.substring(thinkStart);
                                
                                if (beforeThink && !hasFoundJson) {
                                    firstJsonContent += beforeThink;
                                }
                                firstThinkingContent += afterThink;
                                
                                // 第一次不更新显示，只记录日志
                                console.log('第一次AI思考内容收集中:', firstThinkingContent);
                            } else if (isInThinking && content.includes('</think>')) {
                                const thinkEnd = content.indexOf('</think>');
                                const beforeEnd = content.substring(0, thinkEnd);
                                const afterEnd = content.substring(thinkEnd + 8);
                                
                                firstThinkingContent += beforeEnd;
                                console.log('第一次AI思考内容收集完成:', firstThinkingContent.trim());
                                
                                isInThinking = false;
                                hasFoundJson = true;
                                firstJsonContent += afterEnd.replace(/^\s+/, '');
                            } else if (isInThinking) {
                                firstThinkingContent += content;
                                console.log('第一次AI思考内容增量收集:', content);
                            } else if (hasFoundJson || !isInThinking) {
                                firstJsonContent += content;
                            }
                        }
                    } catch (e) {
                        console.warn('解析流数据失败:', e, 'data:', data);
                    }
                }
            }
        }

        console.log('First AI 完整内容:', firstAllContent);
        console.log('First AI 思考内容:', firstThinkingContent);
        console.log('First AI JSON内容:', firstJsonContent);

        // 解析第一次AI的JSON结果
        let jsonToParse = firstJsonContent || firstAllContent;
        if (jsonToParse) {
            analysisResult = this.parseAIJsonResponse(jsonToParse);
            if (!analysisResult) {
                throw new Error('解析第一次 AI 响应失败');
            }

            // 验证基本结构
            if (!analysisResult || !Array.isArray(analysisResult.Category) || !Array.isArray(analysisResult.Type) || !Array.isArray(analysisResult.Target)) {
                console.error('First AI 返回的 JSON 结构不符合预期:', analysisResult);
                throw new Error('First AI 返回的 JSON 结构不符合预期');
            }
            
            console.log('First AI Analysis Result:', analysisResult);

        } else {
            throw new Error('First AI 响应格式不正确');
        }
    } catch (error) {
        console.error('第一次调用 AI 失败:', error);
        return {
            description: `抱歉，分析您的请求时遇到问题：${error.message}`,
            recommendations: [],
            searchResults: []
        };
    }

    // --- 数据查询 ---
    // 更新描述为数据查询阶段
    this.description = '正在查询相关数据...';
    
    let fetchedData = {
        nearbyComments: null,
        nearbyActivities: null,
        userContent: null,
        friendList: null
    };
    const promises = [];
    const { Category, Type, Target } = analysisResult;
    const userId = this.userInfo?.userId;
    const latitude = this.userInfo?.latitude;
    const longitude = this.userInfo?.longitude;

    if (Target.includes("全局")) {
        if (Type.includes("评论") && latitude && longitude) {
            promises.push(
                this.fetchBackendData("/comments/nearby/", { latitude:latitude, longitude:longitude, Category: Category, limit: 10, page: 1 })
                    .then(data => { 
                        if(data && Array.isArray(data)) {
                            let processedComments = data.map(comment => ({
                                类型: '评论', ID: comment.commentId, 标题: comment.commentTitle, 内容: comment.commentContent, 
                                参与时间: comment.commentPublishTime, 位置: comment.location, 距离: comment.distance, ...comment
                            }));
                            fetchedData.nearbyComments = processedComments;
                            console.log('Processed Nearby Comments:', fetchedData.nearbyComments);
                        } else {
                            fetchedData.nearbyComments = []; 
                        }
                    })
                    .catch(err => { console.error("获取附近评论失败:", err); fetchedData.nearbyComments = []; })
            );
        }
        if (Type.includes("活动") && latitude && longitude) {
            promises.push(
                this.fetchBackendData("/activities/nearby/", { latitude:latitude, longitude:longitude, Category: Category, limit: 10, page: 1 })
                    .then(data => { 
                        if(data && Array.isArray(data)) {
                            console.log('获取到的原始活动数据:', data);
                            let processedActivities = data.map(activity => ({
                                类型: '活动', ID: activity.activityId, 标题: activity.activityTitle, 内容: activity.activityDetails, 
                                参与时间: activity.activityPublishTime, 位置: activity.location, 距离: activity.distance, ...activity
                            }));
                            fetchedData.nearbyActivities = processedActivities;
                            console.log('Processed Nearby Activities:', fetchedData.nearbyActivities);
                        } else {
                            fetchedData.nearbyActivities = []; 
                        }
                    })
                    .catch(err => { console.error("获取附近活动失败:", err); fetchedData.nearbyActivities = []; })
            );
        }
    }

    if (Target.includes("自己") && userId) {
        promises.push(
            this.fetchBackendData("/users/content/", { userId: userId })
                .then(data => {
                    if (data && data.status === 'success') {
                        let processedContent = [];
                        if (Array.isArray(data.activities)) {
                            processedContent = processedContent.concat(data.activities.map(activity => ({
                                类型: '活动', ID: activity.activityId, 标题: activity.activityTitle, 内容: activity.activityDetails, 参与时间: activity.activityPublishTime, ...activity
                            })));
                        }
                        if (Array.isArray(data.comments)) {
                             processedContent = processedContent.concat(data.comments.map(comment => ({
                                类型: '评论', ID: comment.commentId, 标题: comment.commentTitle, 内容: comment.commentContent, 参与时间: comment.commentPublishTime, ...comment
                            })));
                        }
                        processedContent.sort((a, b) => new Date(b.参与时间) - new Date(a.参与时间));
                        fetchedData.userContent = processedContent;
                        console.log('Processed User Content:', fetchedData.userContent);
                    } else {
                         console.warn('获取用户内容失败或数据格式不正确:', data);
                         fetchedData.userContent = [];
                    }
                })
                .catch(error => {
                     console.error('处理用户内容数据时出错:', error);
                     fetchedData.userContent = [];
                })
        );
    }

    if (Type.includes("好友") && userId) {
        promises.push(
            this.fetchBackendData("/friends/list/", { user_id: userId })
                .then(data => { if(data && Array.isArray(data)) fetchedData.friendList = data; else fetchedData.friendList = []; })
                 .catch(err => { console.error("获取好友列表失败:", err); fetchedData.friendList = []; })
        );
    }

    try {
        await Promise.all(promises);
        console.log('Fetched Backend Data:', fetchedData);
    } catch (error) {
        console.error('查询后端数据时出错:', error);
    }

    // --- 整合并标准化所有获取到的数据 ---
    let allItems = [];
    if (fetchedData.nearbyComments) {
        allItems = allItems.concat(fetchedData.nearbyComments.map(item => this.mapItemToFrontendFormat(item, '评论')));
    }
    if (fetchedData.nearbyActivities) {
        allItems = allItems.concat(fetchedData.nearbyActivities.map(item => this.mapItemToFrontendFormat(item, '活动')));
    }
    if (fetchedData.userContent) {
        allItems = allItems.concat(fetchedData.userContent.map(item => this.mapItemToFrontendFormat(item, '自己')));
    }

    console.log('All Formatted Items for AI:', allItems);

    if (allItems.length === 0) {
        console.log("没有获取到任何相关数据，无法进行推荐。");
        return {
            description: "抱歉，未能找到相关内容。",
            recommendations: [],
            searchResults: []
        };
    }

    // --- 在第二次AI调用前先展示搜索结果 ---
    // 准备初始搜索结果（所有找到的项目，取前8个）
    const initialSearchResults = allItems.slice(0, 8).map(item => ({
        ...item,
        Content: item.Content || '',
        Location: item.Location || '',
        Time: item.Time || '',
        tags: item.tags || [],
        rating: item.rating || null,
        author: {
            name: item.author?.name || '匿名用户',
            avatar: item.author?.avatar || 'https://via.placeholder.com/20x20'
        }
    }));

    // 立即返回初始结果，让用户先看到搜索结果
    // 使用回调函数来更新UI
    if (this.updateSearchResults) {
        this.updateSearchResults({
            description: '找到了以下相关内容，AI正在为您精心挑选最佳推荐...',
            recommendations: [],
            searchResults: initialSearchResults
        });
    }

    // --- 第二次 AI 调用：选择推荐项 ---
    // 现在开始显示思考状态
    this.isThinking = true;
    this.isLoading = false;
    this.thinkingStage = 'recommending';
    this.description = '正在为您精心挑选推荐...'; // 初始化第二次的描述
    
    const secondSystemPrompt = `
    你是一个智能助理，负责根据用户原始搜索意图和提供的数据列表，选择最符合的一个项目作为推荐。

    你需要返回严格的 JSON 格式，包含以下字段：
    - 类型: 被选中项目的类型 (例如: "评论", "活动")。
    - ID: 被选中项目的 ID。
    - 选中理由: 简要说明为什么选择这个项目推荐给用户 (string)。

    请基于以下信息进行选择和说明：
    - 用户的原始搜索词。
    - 第一次 AI 分析出的意图 (Category, Type, Target)。
    - 提供的数据项列表 (只包含 类型, ID, 标题)。

    **重要：确保返回的 JSON 格式严格有效，可以直接被 JavaScript 的 JSON.parse() 解析。不要在 JSON 之外添加任何其他文本或解释。**
    `;

    const simplifiedItemsForAI = allItems.map(item => ({
        类型: item.类型,
        ID: item.ID,
        标题: item.title,
        内容: item.Content,
        发布时间: item.Time,
        位置: item.Location,
        距离: item.Distance + '公里，' + (item.Distance < 10 ? '非常近' : item.Distance < 50 ? '不远' : item.Distance < 100 ? '有点远' : '很远')
    }));

    let secondUserPrompt = `
    原始搜索词: ${prompt}
    分析意图: ${JSON.stringify(analysisResult)}
    可选数据列表: ${JSON.stringify(simplifiedItemsForAI)}

    请从以上列表中选择最匹配用户意图的一项，并给出选中理由。注意理由不要提及ID，只从心理角度说明选择即可。
    输出示例：
    {
        "类型": "评论",
        "ID": "comment123",
        "选中理由": "让我想想，根据你的习惯我觉得你应该爱吃辣椒吧？，我猜测你是想要找一个四川口味的火锅，那么我选中的这个就很符合你的要求哦。"
    }
    `;

    const secondRequestBody = {
        model: "mini",
        temperature: 0.1,
        top_p: 0.1,
        messages: [
            { role: "system", content: secondSystemPrompt },
            { role: "user", content: secondUserPrompt }
        ],
        stream: true
    };

    try {
        console.log('Second AI Call Request:', JSON.stringify(secondRequestBody, null, 2));
        
        // 流式处理第二次AI调用
        const secondResponse = await fetch("https://api.leftnorth.com/v1/chat/completions", {
            method: 'POST',
            headers: {
                'Accept': 'text/event-stream',
                'Content-Type': 'application/json',
                'Authorization': `Bearer sk-dff7bc8e-084d-45a9-a837-c634e64ca71b`,
            },
            body: JSON.stringify(secondRequestBody)
        });

        if (!secondResponse.ok) {
            throw new Error(`Second AI call HTTP error! status: ${secondResponse.status}`);
        }

        // 处理第二次AI的流式响应 - 这次显示思考内容
        const reader = secondResponse.body.getReader();
        const decoder = new TextDecoder();
        let buffer = '';
        let secondAllContent = '';
        let secondThinkingContent = '';
        let secondJsonContent = '';
        let isInThinking = false;
        let hasFoundJson = false;

        while (true) {
            const { done, value } = await reader.read();
            if (done) break;

            buffer += decoder.decode(value, { stream: true });
            const lines = buffer.split('\n');
            buffer = lines.pop() || '';

            for (const line of lines) {
                if (line.startsWith('data: ')) {
                    const data = line.slice(6).trim();
                    if (data === '[DONE]') continue;
                    if (data === '') continue;
                    
                    try {
                        const parsed = JSON.parse(data);
                        if (parsed.choices && parsed.choices[0] && parsed.choices[0].delta && parsed.choices[0].delta.content) {
                            const content = parsed.choices[0].delta.content;
                            secondAllContent += content;
                            
                            // 第二次AI调用时实时显示思考内容
                            if (content.includes('<think>')) {
                                isInThinking = true;
                                const thinkStart = content.indexOf('<think>') + 7;
                                const beforeThink = content.substring(0, content.indexOf('<think>'));
                                const afterThink = content.substring(thinkStart);
                                
                                if (beforeThink && !hasFoundJson) {
                                    secondJsonContent += beforeThink;
                                }
                                secondThinkingContent += afterThink;
                                
                                // 实时更新思考内容(去除前后空白字符)
                                this.description = secondThinkingContent.trim();
                                console.log('第二次AI实时思考内容更新:', secondThinkingContent);
                            } else if (isInThinking && content.includes('</think>')) {
                                const thinkEnd = content.indexOf('</think>');
                                const beforeEnd = content.substring(0, thinkEnd);
                                const afterEnd = content.substring(thinkEnd + 8);
                                
                                secondThinkingContent += beforeEnd;
                                // 去除思考内容的前后空白字符，包括换行符
                                this.description = secondThinkingContent.trim();
                                console.log('第二次AI思考内容完成:', secondThinkingContent.trim());
                                
                                isInThinking = false;
                                hasFoundJson = true;
                                // 去除afterEnd开头的换行符和空白字符
                                secondJsonContent += afterEnd.replace(/^\s+/, '');
                            } else if (isInThinking) {
                                secondThinkingContent += content;
                                // 实时更新思考内容(去除前后空白字符)
                                this.description = secondThinkingContent.trim();
                                console.log('第二次AI思考内容增量更新:', content, '总内容:', secondThinkingContent.trim());
                            } else if (hasFoundJson || !isInThinking) {
                                secondJsonContent += content;
                            }
                        }
                    } catch (e) {
                        console.warn('解析流数据失败:', e, 'data:', data);
                    }
                }
            }
        }

        console.log('Second AI 完整内容:', secondAllContent);
        console.log('Second AI 思考内容:', secondThinkingContent);
        console.log('Second AI JSON内容:', secondJsonContent);

        // 解析第二次AI的JSON结果
        let jsonToParse = secondJsonContent || secondAllContent;
        if (jsonToParse) {
            const aiChoice = this.parseAIJsonResponse(jsonToParse);

            if (!aiChoice) {
                console.error('解析 Second AI 返回的 JSON 失败');
                return {
                    description: "抱歉，AI 推荐解析失败，为您展示所有找到的结果。",
                    recommendations: [],
                    searchResults: allItems.slice(0, 5)
                };
            }

            // 验证 AI 选择结果结构
            if (aiChoice && typeof aiChoice.类型 === 'string' && aiChoice.ID !== undefined && typeof aiChoice.选中理由 === 'string') {
                console.log('AI Choice:', aiChoice);

                // 1. 查找 AI 推荐的完整项目
                const recommendedItem = allItems.find(item => item.类型 === aiChoice.类型 && String(item.ID) === String(aiChoice.ID));

                let finalRecommendations = [];
                if (recommendedItem) {
                    const enhancedRecommendedItem = {
                        ...recommendedItem,
                        Content: recommendedItem.Content || '',
                        Location: recommendedItem.Location || '',
                        Time: recommendedItem.Time || '',
                        tags: recommendedItem.tags || [],
                        rating: recommendedItem.rating || null,
                        author: {
                            name: recommendedItem.author?.name || '匿名用户',
                            avatar: recommendedItem.author?.avatar || 'https://via.placeholder.com/20x20'
                        }
                    };
                    
                    finalRecommendations = [enhancedRecommendedItem];
                    console.log('Found Recommended Item:', enhancedRecommendedItem);
                } else {
                    console.warn(`AI 推荐的项目 (类型: ${aiChoice.类型}, ID: ${aiChoice.ID}) 在 allItems 中未找到!`);
                }

                // 2. 准备搜索结果（排除 AI 推荐项，取前 5）
                const finalSearchResults = allItems
                    .filter(item => !(item.类型 === aiChoice.类型 && String(item.ID) === String(aiChoice.ID)))
                    .slice(0, 5)
                    .map(item => ({
                        ...item,
                        Content: item.Content || '',
                        Location: item.Location || '',
                        Time: item.Time || '',
                        tags: item.tags || [],
                        rating: item.rating || null,
                        author: {
                            name: item.author?.name || '匿名用户',
                            avatar: item.author?.avatar || 'https://via.placeholder.com/20x20'
                        }
                    }));

                console.log('Final Recommendations:', finalRecommendations);
                console.log('Final Search Results:', finalSearchResults);

                // 返回最终结果，使用AI的选中理由作为最终描述
                return {
                    description: aiChoice.选中理由,
                    recommendations: finalRecommendations,
                    searchResults: finalSearchResults
                };

            } else {
                console.error('Second AI 返回的 JSON 结构不符合预期:', aiChoice);
                return {
                    description: "抱歉，AI 推荐的格式不正确，为您展示所有找到的结果。",
                    recommendations: [],
                    searchResults: allItems.slice(0, 5)
                };
            }
        } else {
            throw new Error('Second AI 响应格式不正确');
        }
    } catch (error) {
        console.error('第二次调用 AI 或处理推荐失败:', error);
        return {
            description: `抱歉，生成推荐时遇到问题：${error.message}`,
            recommendations: [],
            searchResults: allItems.slice(0, 5)
        };
    }
}, // callAI 方法结束
// 辅助函数：将后端数据项映射到前端所需的统一格式
// 注意：你需要根据后端返回的实际字段来调整这个函数
mapItemToFrontendFormat(item, type) {
    // 默认结构
    let formattedItem = {
        类型: type, // '评论', '活动', '好友' 等
        ID: null,
        title: '未知标题',
        image: 'https://via.placeholder.com/100x80/CCCCCC/FFFFFF?text=No+Image', // 默认图片
        tags: [],
        Content: '无内容',
        Location: '未知位置',
        Time: '未知时间',
        author: { name: '匿名用户', avatar: 'https://via.placeholder.com/20x20/CCCCCC/FFFFFF?text=?' },
        activityTag: type === '活动' ? '活动' : null,
        rating: null, // 或从 item 中获取
        // 其他前端需要的字段...
        originalData: item // 保留原始数据以备后用
    };

    if (type === '评论' && item) {
        formattedItem.ID = item.commentId;
        formattedItem.title = item.commentTitle || '用户评论';
        formattedItem.Content = item.commentContent || '';
        //地点
        formattedItem.Location = item.commentLocation || '';
        formattedItem.Distance = item.distance || '';
        formattedItem.Time = item.commentPublishTime || '';
        formattedItem.tags = item.tags || []; // 假设评论有标签
        formattedItem.author.name = item.publisherNickname || '匿名用户';
        formattedItem.author.avatar = item.publisherAvatar || formattedItem.author.avatar;
        formattedItem.rating = item.rating ? `${item.rating}` : null; // 假设有评分
        formattedItem.image = item.commentImages && item.commentImages.length > 0 ? item.commentImages[0] : formattedItem.image;
// ... existing code ...
    } else if (type === '活动' && item) {
        formattedItem.ID = item.activityId;
        formattedItem.title = item.activityTitle || '社区活动';
        formattedItem.Content = item.activityDetails || '';
        formattedItem.Location = item.activityLocation || '';
        formattedItem.Distance = item.distance || '';
        formattedItem.Time = item.activityPublishTime || '';
        formattedItem.tags = item.tags || []; // 假设活动有标签
        formattedItem.author.name = item.publisherNickname || '活动发起人';
        formattedItem.author.avatar = item.publisherAvatar || formattedItem.author.avatar;
        formattedItem.image = item.activityImages && item.activityImages.length > 0 ? item.activityImages[0] : formattedItem.image;
    } else if (type === '自己' && item) { // 处理来自 userContent 的数据
        formattedItem.类型 = item.类型; // '评论' 或 '活动'
        formattedItem.ID = item.ID;
        formattedItem.title = item.标题 || '我的记录';
        formattedItem.tags = item.tags || [];
        formattedItem.Content = item.activityDetails || item.commentContent || '';
        formattedItem.Location = item.activityLocation || item.commentLocation || '';
        formattedItem.Time = item.activityPublishTime || item.commentPublishTime || '';
        // userContent 可能没有作者信息，使用默认或从 this.userInfo 获取
        formattedItem.author.name = item.publisherNickname || '我';
        formattedItem.author.avatar = item.publisherAvatar || formattedItem.author.avatar;
        formattedItem.activityTag = item.类型 === '活动' ? '活动' : null;
        formattedItem.image = (item.commentImages || item.activityImages) && (item.commentImages || item.activityImages).length > 0 ? (item.commentImages || item.activityImages)[0] : formattedItem.image;
    }
    // 你可能需要为 '好友' 类型添加映射逻辑

    // 确保所有字段都有合理的值
    formattedItem.title = formattedItem.title || (type === '评论' ? '用户评论' : (type === '活动' ? '社区活动' : '未知内容'));
    console.log('Mapped Item:', formattedItem);
    return formattedItem;
},

search() {
    if (!this.searchText.trim()) return;

    this.isLoading = true;
    this.isThinking = false; // 开始时不显示思考状态
    this.thinkingStage = 'analyzing'; // 设置思考阶段为分析
    this.startLoadingAnimation(); // 启动加载动画
    this.showContent = true; // 立即显示内容区域
    this.recommendations = [];
    this.searchResults = [];
    this.description = '正在分析您的搜索意图...'; // 初始化描述
    this.visibleRecommendations = [];
    this.visibleSearchResults = [];
    this.showHotPot = false; // 重置火锅店显示

    this.callAI(this.searchText)
        .then(aiResult => {
            // AI调用完成后，更新最终描述
            if (aiResult.description) {
                this.description = aiResult.description;
            } else {
                this.description = "未能获取推荐描述。";
            }
            
            this.recommendations = aiResult.recommendations || [];
            this.searchResults = aiResult.searchResults || [];

            // 更新 showHotPot 逻辑（如果需要）
            this.showHotPot = [...this.recommendations, ...this.searchResults].some(item => 
                item.title && item.title.includes('火锅')
            );

            this.thinkingStage = 'completed'; // 思考完成
            this.isThinking = false; // 结束思考状态
            
            this.$nextTick(() => {
                this.animateItems(); // 触发入场动画
            });
        })
        .catch(error => {
            console.error("搜索过程中发生错误:", error);
            this.description = "抱歉，搜索时遇到问题，请稍后重试。";
            this.recommendations = [];
            this.searchResults = [];
            this.thinkingStage = 'completed'; // 即使出错也标记为完成
            this.isThinking = false; // 结束思考状态
        })
        .finally(() => {
            this.isLoading = false;
            this.stopLoadingAnimation();
        });
},

        // 新增：启动加载文本动画的方法
        startLoadingAnimation() {
            // 先立即显示一条
            this.currentLoadingText = this.loadingTexts[Math.floor(Math.random() * this.loadingTexts.length)];
            // 设置定时器，每隔一段时间切换文本
            this.loadingInterval = setInterval(() => {
                const randomIndex = Math.floor(Math.random() * this.loadingTexts.length);
                this.currentLoadingText = this.loadingTexts[randomIndex];
            }, 1500); // 每 1.5 秒切换一次，可以调整时间
        },

        // 新增：停止加载文本动画的方法
        stopLoadingAnimation() {
            if (this.loadingInterval) {
                clearInterval(this.loadingInterval);
                this.loadingInterval = null;
            }
        },
        
        // 逐条显示动画
        animateItems() {
            // 显示推荐结果
            for (let i = 0; i < this.recommendations.length; i++) {
                setTimeout(() => {
                    this.visibleRecommendations.push(i);
                }, i * 200);
            }
            
            // 显示搜索结果
            const recommendationDelay = this.recommendations.length * 200;
            for (let i = 0; i < this.searchResults.length; i++) {
                setTimeout(() => {
                    this.visibleSearchResults.push(i);
                }, recommendationDelay + i * 200);
            }
        },
        
        // 获取模拟数据
        getMockData() {
            return {
                description: `嗨，用户让我推荐他最爱吃的食物，根据用户历史喜好分析，用户在往期选择中选择烤鸡类食物较多，所以我可以提供一些烤鸡食物。\n尽管我可以尝试从用户历史中为你提供更多相关的食物推荐，这个答案可能不是最理想的回答，但是为了提供更加准确的推荐，我可以尝试从好友中给你一个更好的相关推荐。`,
                recommendations: [
                    {
                        title: '一起吃烤鸭',
                        image: 'https://via.placeholder.com/100x80',
                        tags: ['美食', '北京味道', '多人'],
                        author: {
                            name: '波比不熬夜',
                            avatar: 'https://via.placeholder.com/20x20'
                        },
                        activityTag: '活动',
                        rating: '2'
                    }
                ],
                searchResults: [
                    {
                        title: '一起吃宫菜',
                        image: 'https://via.placeholder.com/100x80',
                        tags: ['美食', '北京味道', '多人'],
                        author: {
                            name: '波比不熬夜',
                            avatar: 'https://via.placeholder.com/20x20'
                        },
                        activityTag: '活动',
                        rating: '2'
                    },
                    {
                        title: '超级火锅店',
                        image: 'https://via.placeholder.com/100x80',
                        tags: ['火锅', '聚餐'],
                        author: {
                            name: '美食达人',
                            avatar: 'https://via.placeholder.com/20x20'
                        }
                    }
                ]
            };
        },
        
        // 打开详情页
        openDetail(item) {
            
            console.log('打开详情页:', item.title);
            Android.openActivity(item.title);
            //alert('即将打开详情页: ' + item.title);
            // 实际应用中这里会跳转到详情页
        },
            // 处理活动项目点击
        openactivities(item) {
            console.log('打开活动详情:', item);
            // 这里添加打开活动详情的逻辑
            // 例如跳转到活动详情页面
            Android.openActivity(item.ID);
            // window.location.href = `/activity.html?id=${item.ID}`;
        },
        
        // 处理评论项目点击
        opencomments(item) {
            console.log('打开评论详情:', item);
            // 这里添加打开评论详情的逻辑
            // 例如跳转到评论详情页面
            Android.openReview(item.ID);
            // window.location.href = `/comment.html?id=${item.ID}`;
        }
    },
    // 新增：在组件销毁前清除定时器，防止内存泄漏
    beforeDestroy() {
        this.stopLoadingAnimation();
    }
});